код програми # коментар

print "Hello World!" # вивести на екран рядок

a = input("Введіть перше число: ") # ввести a
b = input("Введіть друге число: ") # ввести b
c=a+b # присвоїти c значення виразу a+b
print c # вивести на екран c

a=16 # ціле десяткове int
b=020 # ціле вісімкове int
c=0x10 # ціле шістнадцяткове int
d=e=16L # довге ціле long
print a,b,c,d,e,type(e)
x=5.71 # дійсне float
y=-3.95e+3 # дійсне float
print x,y
i=True # булеве bool
print i
cn1=1+1j # комплексне complex
print cn1

a=int("7") # перетворення в ціле
b=long(9.7) # перетворення в довге ціле
x=float("3.14") # перетворення в дійсне
cn1=complex(1,1) # перетворення в комплексне
cn2=(1+2j)/cn1 # ділення комплексних чисел
m=abs(cn2) # модуль комплексного числа
i=bool(2>1) # перетворення в булеве
y=abs(-1.2) #модуль y=(-1.2).__abs__()
print a,b,x,cn2,cn2.real,cn2.imag,m,i,y
z=(-x*y+1)/y**2 # вираз із операторами: унарний мінус, множення, додавання, ділення, степінь
r=9/5 # ділення цілих r=(9).__div__(5)
u=9//5 # цілочисельне ділення
v=9%5 # остача від ділення
w=divmod(9,5) # кортеж 9//5, 9%5
j=2>1 and 1<=0 and not(1==1 or 1!=0 or False) # логічний вираз
k=round(2.91754,2) # заокруглити до 2 знаків після коми
# вивести допомогу по функції: help(round)
print z,r,u,v,w,j,k
print eval("a+b") # значення динамічно побудованого виразу
exec r"print a+b" # виконти Python-код (див. також execfile)

x = 2 # присвоїти x 2
if x<0: # якщо x<0 то
    y=1 # присвоїти y 1
    print "x<0, y=",y # вивести на екран
elif x>1 or x==0: # інакше, якщо x>0 або x=0 то
    y=2 # присвоїти y 2
    print "x>0, y=",y # вивести на екран
else: # інакше
    y=0 # присвоїти y 0
    print "x=0, y=",y # вивести на екран

for x in range(0,11): # для x в діапазоні [0,11)
    print x**2, # вивести на екран квадрат x

x=0 # присвоїти x 0
while x<=10: # поки x менше рівне 10
    print x**2, # вивести на екран квадрат x
    x=x+1 # збільшити x

x=0 # присвоїти x 0
while x<=10: # поки x менше рівне 10
    y=x**2
    x+=1 # збільшити x
    if y>50: # якщо y>50
        break # перервати цикл
    elif 10<y<30: # якщо 10<y<30
        print "*", # вивести на екран "*"
        continue # перейти до наступної ітерації
    print y, # вивести на екран y

a = (1,2,3,4,5) # кортеж
b = "a",5,3.07 # кортеж із різнотипними елементами
x,y=3,5 # використання кортежу в операторі присвоювання
print a,len(a),b,len(b) # вивести кортежі і їхні довжини
# вивести елементи [індекс першого:індекс останнього:крок]
print a[0],a[-1],a[1:4:2],a[::2]
print min(b),max(b) # мінімальне і максимальне
print a+b # об'єднання
print 2*a # об'єднані 2 копії
print "a" in b # чи "a" належить b
for x in a: # для кожного x у a
    print x, # вивести x

s1="Рядок1" # рядок
s2='"String"2\n' # рядок зі спецсимволом переводу рядка
s3='''Str
ing3''' # рядок із переводом рядка
s4=r"String\t4\n" # необроблюваний рядок
s5=u"String5" # Unicode рядок
s6=ur"String6\n" # Unicode необроблюваний рядок
print s1,s2,s3,s4,s5,s6,len(s6) # вивести рядки і довжину рядка s6
print s1+" "*5+str(3.14)+" "+repr(3.14) # об'єднання рядків
print s1[2],s1[:2],s1[2:],s1[-2] # зрізи рядка
print "я" in s1 # чи "я" належить s1
for x in s1: pass # для кожного символу x у s1 виконати пусту команду
print "x= %*.*f%s"%(5,2,51.2935,"mm") # форматування рядка
print "x= %4d %o %x"%(16,16,16) # форматування рядка
print "x= {0} {unit}".format('five', unit='mm') # форматування рядка
print "   hello  ".strip() # видалити пробіли на початку і в кінці
print "hello world!".find("ll",0,4) # знайти входження підрядка на проміжку
print "hello".replace("h","H",1) # замінити 1 раз "h" на "H"
lst="a,b,c".split(",") # розбити рядок на список (розділювач ",")
s1="" # пустий рядок
print s1.join(lst) # об'єднати список у рядок
print oct(16), hex(16) # вивести рядкове представлення вісімкового і шістнадцяткового числа
print ord('A'),chr(65),unichr(65),unicode('ABC','utf-8') # вивести код символу, символ за кодом, символ Unicode за кодом, об'єкт у заданому кодуванні

s='звичайний рядок'
us=u'юнікод-рядок'
print type(s),isinstance(s, str) # <type 'str'> True
print type(us),isinstance(us, unicode) # <type 'unicode'> True
s2=us.encode('utf-8') # кодує в звичайний рядок utf-8
us2=s.decode('utf-8') # декодує звичайний рядок utf-8 в юнікод-рядок
us2=unicode(s, 'utf-8') # або так
print type(s2) # <type 'str'>
print type(us2) # <type 'unicode'>
print len('рядок') # 10 , бо кодується utf-8 (символи кодуються 1-6 байтами)
print len(u'рядок') # 5

from __future__ import unicode_literals
print type('текст') # тип 'unicode', а не 'str'
print type(u'текст') # тип 'unicode'

a = [1,2,3,4,5] # список
b=[1.0/x for x in range(1,4) if x!=2] # генератор списку
c=list("string") # список із рядка
d=range(5) # список із прогресії
e=[1,"abc",2.3,(1+1j),a] # список із різнотипними елементами
print a,len(a),b,len(b) # списки і їхні довжини
print e[4] # вивести елемент з індексом 4 (список a)
print a[0],a[-1],a[1:4:2],a[::2] # вивести елементи [індекс першого:індекс останнього:крок]
print min(a),max(a) # мінімальне і максимальне
print a+[6,7] # об'єднання
print 2*a # об'єднані 2 копії
print 3 in a # чи 3 належить a
a[0]=2 # присвоїти значення елементу з індексом 0
a[::2]=[0,0,0] # непарним елементам присвоїти 0
del a[4] # видалити елемент з індексом 4
a.append(5) # додати в кінець 5
a.extend([6,7]) # розширити список
print a.count(0) # кількість елементів рівних 0
print a.index(5) # мінімальний індекс елемента зі значенням 5
a.insert(1,9) # вставити в позицію 1
print a.pop(1) # вивести елемент з індексом 1 і видалити
a.reverse() # обернути список
a.sort() # сортувати за зростанням
for x in a[:]: # для кожного x у копії a
    print x, # вивести x

d1={1:"Іванов",2:"Петров",3:"Коваль"} # словник
d2=dict([("Іванов",1982),("Петров",1980),("Коваль",1978)]) # словник
d3=dict(x=1.5,y=5.2,z=3.0) # словник
d2["Іванов"]=1983 # зміна значення за ключем "Іванов"
del d2["Іванов"] # видалити елемент за ключем
print "Петров" in d2 # чи є ключ "Петров" у словнику d2
for k,v in d2.iteritems():print k,v, # цикл за елементами
print
for k in d2.iterkeys():pass # цикл за ключами
for v in d2.itervalues():pass # цикл за значеннями
l3=d2.items() # список з елементів-пар (ключ,значення)
l1=d2.keys() # список із ключів
l2=d2.values() # список зі значень
print d2.get("Петров",0) # значення за ключем, якщо немає - 0
d4=d1.fromkeys([1,2,3],"Male") # новий словник із ключів d1
print d4 # вивести словник

s1={1,1,2,3,2,5,3,1,5} # множина
s2=set([7,7,8,9,1,2]) # множина зі списку
s3=set("hello") # множина з рядка
print s1,len(s1),s2,len(s2) # вивести множини і їхні довжини
print 2 not in s1 # чи 2 не в множині s1?
for x in s1: pass # для кожного в множині виконати пусту команду
s1.add(7) # додати елемент
s1.remove(7) # видалити елемент
s1.discard(7) # видалити елемент, якщо він є
print s1.pop() # вивести довільний і видалити його
print s1.issubset(s2) # чи кожен у s1 є у s2 (s1 <= s2)
print s1.issuperset(s2) # чи кожен у s2 є у s1 (s1 >= s2)
print s1.union(s2) # об'єднання (s1 | s2)
print s1.intersection(s2) # перетин (s1 & s2)
print s1.difference(s2) # різниця (s1 - s2)
print s1.symmetric_difference(s2) # симетрична різниця (s1 ^ s2)

def sum(a,b=0): #визначити функцію з параметрами a, b
    "Повертає суму двох чисел" # рядок документації
    c=a+b
    return c # функція повертає значення c
print sum(2,2), # вивести значення функції (a=2, b=2)
print sum(a=2,b=2), # або так
print sum(2) # вивести значення функції (a=2, b=0)
print sum.__doc__ # вивести документацію

def f(a,*b,**c):
    print a,b,c # тут b - кортеж, c - словник
f(1,2,3,x=4,y=5) # a=1 b=(2, 3) c={'y': 5, 'x': 4}
f(a=1,b=2,c=3,x=4,y=5) # a=1 b=() c={'y': 5, 'x': 4, 'c': 3, 'b': 2}

f = lambda x, y: x + y # визначення функції за допомогою виразу
print f(2,3) # вивести значення функції (x=2,y=3)

def bin(n): # рекурсивна функція
    "Повертає список із двійковим поданням числа"
    if n == 0: return [] # якщо n == 0, повертає пустий список
    n, d = divmod(n, 2) #або n=n//2; d=n%2
    return bin(n) + [d] # повертає bin(n) + [d]
print bin(5) # виклик функції

a=0 # глобальна змінна
def func(b): # функція
    def fn(c): # внутрішня функція (замикання)
        global a # звертання до глобальної змінної
        a=1 # зміна значення глобальної змінної
        print a,b,c # вивести a,b,c
    print 'func'
    return fn # повернути функцію
f=func(2) # аргумент b=2, виведе: 'func'
f(3) # аргумент c=3, виведе: 1 2 3
print a # 1 - значення глобальної змінної змінилось

import sys # імпорт модуля sys
for x in -1, 0, "0.2", 1e1000: # повторити наступні команди для різних значень змінної x
    try: # перехоплювати помилки виконання
        assert x>=0 # якщо x менше 0, генерувати AssertionError
        y=int(x) # помилка ValueError
        z=1/x # помилка ZeroDivisionError
    except ZeroDivisionError: # якщо ділення на нуль
        print x,"Помилка! Ділення на нуль"
    except: # якщо інші помилки
        print x,sys.exc_type # вивести тип помилки

f1=open("file1.txt", "w") # відкрити текстовий файл для запису
f1.write("Line1\n") # записати рядок ('\n' - символ кінця рядка)
f1.close() # закрити файл

f2=open("file1.txt", "a") # відкрити текстовий файл для добавлення
f2.writelines(("Line2\n","Line3\n")) # записати послідовність рядків
f2.close() # закрити файл

f3=open("file1.txt", "r+") # відкрити текстовий файл для читання і запису
print f3.read() # читати весь файл
f3.seek(0) # установити позицію на початок файлу
print f3.readline(),f3.tell() # читати рядок, вивести поточну позицію
print f3.readlines() # читати список рядків до кінця
f3.seek(0) # установити позицію на початок файлу
for line in f3: # для кожного рядку у файлі
    pass # виконати пусту команду
f3.close() # закрити файл

f4=open("file1.txt", "rb") # відкрити бінарний файл для читання
# спробуйте також відкрити цей файл як текстовий "r"
f4.seek(7) # установити позицію після байта 7
while True: # читає файл побайтово
    b=f4.read(1) # читати байт
    if not b: break # перервати цикл, якщо байтів немає
    print ord(b), # числове подання Юнікод-символу
#зверніть увагу на два байти (13 10), які в текстових файлах Windows використовуються для позначення кінця рядка
f4.close() # закрити файл

import sys # імпортує модуль (і тільки 1 раз)
import module1 as m # імпортувати модуль і змінити його ім'я на m
from package1 import * # імпортувати з пакету все
#або
#from package1.module1 import * # імпортувати з модуля все
#from package1.module2 import * # імпортувати з модуля все
if __name__ == '__main__':# якщо модуль виконується, а не імпортується
    print __name__, __file__ # ім'я і файл модуля
    #print sys.path # шляхи пошуку модулів
    sys.path.append("c:\SomeFolder") # додати шлях пошуку модулів
    print m.__doc__ # рядок документації модуля
    print m.__dict__.keys() # список імен
    m.a='a_'
    m.f() # виведе 'a_'
    print a,b,c
    reload(m) # повторно завантажити модуль
    print m.a # виведе 'a'

'''module1 doc''' # рядок документації модуля
print __name__, __file__
a='a' # атрибут модуля
def f(): # атрибут модуля
    print a

# цей файл виконується під час імпорту пакета
print __name__, __file__
from module1 import *
from module2 import *

print __name__, __file__
a='a' # атрибут модуля
from module2 import b # з модуля копіювати b
# зверніть увагу на порядок інструкцій і будьте уважні з рекурсивним імпортом
print b

print __name__, __file__
b='b' # атрибут модуля
c='c' # атрибут модуля
d='d' # не буде імпортуватись інструкцією from *
_e='_e' # не буде імпортуватись інструкцією from *
from module1 import * # зверніть увагу на порядок інструкцій
print a
__all__=[b,c] # список імен, які імпортуються інструкцією from *

from math import * # імпортувати усе з модуля math
x,y=1,1
acos(x) # арккосинус x
asin(x) # арксинус x
atan(x) # арктангенс x
atan2(y,x) # atan(y/x)
ceil(x) # найменше ціле, більше або рівне x
cos(x) # косинус x
cosh(x) # гіперболічний косинус x
e # константа e
exp(x) # експонента (e**x)
fabs(x) # абсолютне значення x
floor(x) # найбільше ціле, менше або рівне x
fmod(x,y) # остача від ділення x на y
frexp(x) # мантиса і порядок x як пара (m, i), де m - число з плаваючою комою, а i - ціле, таке, що x = m * 2.**i. Якщо x=0, то повертає (0,0), інакше 0.5 <= abs(m) < 1.0
hypot(x,y) # sqrt(x*x + y*y)
ldexp(x,y) # x * (2**y)
log(x) # натуральний логарифм x
log10(x) # десятковий логарифм x
modf(x) # пара (y,q) - ціла та дробова частина x. Обидві частини мають знак x
pi # константа пі
pow(x,y) # x в степені y (або x**y)
sin(x) # синус x
sinh(x) # гіперболічний синус x
sqrt(x) # корінь квадратний від x
tan(x) # тангенс x
tanh(x) # гіперболічний тангенс x

a=[1,2,3,4,5] # список
def fn1(x): return x!=3 # функція повертає істину, якщо x не 3
print filter(fn1,a) # відфільтрований функцією fn1 список
#print filter(lambda x:x!=3,a) # або так
#print [x for x in a if x!=3] # або так
def fn2(x): return x**2 # функція повертає квадрат числа
print map(fn2,a) # застосовує fn2 до кожного елемента
def fn3(x,y): return x+y # функція повертає суму двох чисел
print map(fn3,a,[1,2,3,4,5]) # сума списків
#print map(lambda x,y:x+y,a,[1,2,3,4,5]) # або так
#print [x+y for x,y in zip(a,[1,2,3,4,5])] # або так
print reduce(fn3,a) # підрахувати (((1+2)+3)+4)+5
#print reduce(lambda x, y: x + y, a) # або так
print zip([1,2,3],[4,5,6]) # об'єднати списки
print [i for i in enumerate("abc")] # пронумерований список
print sorted([(1,2),(2,1),(3,3)], key=lambda x: x[1]) # сортувати за елементами з індексом 1

def generator(n): # функція генератора (генерує послідовність)
    while n<3:
        yield n # генерувати значення n
        n+=1
genObj=generator(0) # створити об'єкт генератора, який має можливість ітерації (є ітератором)
print genObj.next(), genObj.next(), genObj.next() # 0 1 2
#print genObj.next() # помилка: StopIteration
for x in generator(0): # або так
    print x, # виведе: 0 1 2
print
def generator2(n): # функція генератора з кількома інструкціями yield
    while n<3:
        yield n # генерувати значення n
        yield n # генерувати значення n
        n+=1
for x in generator2(0):
    print x, # виведе: 0 0 1 1 2 2

def coroutine(): # співпрограма обробляє послідовність вхідних даних
    while True:
        x=(yield) # отримати дані через send()
        yield 2*x # генерувати значення 2*x
corObj=coroutine() # створити об'єкт генератора
for x in [1,2,3]: # виведе: 2 4 6
    corObj.next() # переміститись до першої інструкції (yield)
    print corObj.send(x), # передати дані співпрограмі через вираз (yield), отримати значення після другої інструкції yield
corObj.close() # завершити роботу з corObj